﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
using namespace std;

class Date
{
public:

	//全缺省构造函数
	Date(int year=99, int month = 99, int day = 99)
		//,_day(day)
	{
		
	}
	Date(const Date& d)
	{

	}
	void print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	~Date()
	{
		_year++;
	}
	static int add()
	{
		return _year;
	}
	void fun( Date a)
	{

	}

private:
	
	static int _year;//静态成员
	int _month;//月-
	int _day;//日
};
//静态成员初始化
int Date::_year = 0;



int main()
{
	/*Date d1;
	Date d2 = d1;
	fun(d1);
	cout << Date::_year << endl;
	cout << d1._year << endl;*/
	Date d1;
	Date d2 = d1;
	d1.fun(d2);
	cout << d1.add() << endl;
}



//class fang
//{
//public:
//    fang(int n)
//    {
//
//    }
//private:
//    int a;
//};
//
//
//typedef int STDataType;
//class Stack
//{
//public:
//    //构造函数
//    Stack(int n = 4)
//    {
//        _a = (STDataType*)malloc(sizeof(STDataType) * n);
//        if (nullptr == _a)
//        {
//            perror("malloc申请空间失败");
//            return;
//        }
//        _capacity = n;
//        _top = 0;
//    }
//
//    
//
//    ////析构函数
//    //~Stack()
//    //{
//    //    cout << "~Stack" << endl;
//    //    free(_a);
//    //    _capacity = 0;
//    //    _top = 0;
//    //}
//
//private:
//    STDataType* _a;
//    size_t _capacity;
//    size_t _top;
//};
//
//
////2个队列实现栈
//class MyQueue
//{
//public:
//    MyQueue(int n = 1)
//        :pushst(n)
//        ,popst(n)
//    {
//
//    }
//
//private:
//	Stack pushst;
//	Stack popst;
//    int n1;
//    const int n2=1;
//};
//
//
//int main()
//{
//  /*  int i = 0;*/
//    MyQueue m1;
//	//MyQueue m2(i,10);
//    MyQueue d1;
//	return 0;
//}


//#include<iostream>
//using namespace std;
//class A
//{
//public:
//	// 构造函数explicit就不再⽀持隐式类型转换
//	// explicit A(int a1)
//	A(int a1)
//		:_a1(a1)
//	{}
//	//explicit A(int a1, int a2)
//	A(int a1, int a2)
//		:_a1(a1)
//		, _a2(a2)
//	{}
//	void Print(int n)
//	{
//		cout << _a1 << n << _a2 << endl;
//	}
//	int Get() const
//	{
//		return _a1 + _a2;
//	}
//private:
//	int _a1 = 1;
//	int _a2 = 2;
//};
//class B
//{
//public:
//	B(const A& a)
//		:_b(a.Get())
//	{}
//private:
//	int _b = 0;
//};
//int main()
//{
//	// 1构造⼀个A的临时对象，再⽤这个临时对象拷⻉构造aa3
//	// 编译器遇到连续构造+拷⻉构造->优化为直接构造
//	A aa1 = 1;
//	aa1.Print(1);
//	const A& aa2 = 1;
//	// C++11之后才⽀持多参数转化
//	A aa3 = { 2,2 };
//	// aa3隐式类型转换为b对象
//	// 原理跟上⾯类似
//	B b = aa3;
//	const B& rb = aa3;
//	return 0;
//}
